{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build Neurons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Contents**\n",
    "\n",
    "\n",
    "* [brainpy.NeuType](#brainpy.NeuType)\n",
    "* [brainpy.NeuGroup](#brainpy.NeuGroup)\n",
    "* [Reconcile the scalar- and vector-based model](#Reconcile-the-scalar--and-vector-based-model)\n",
    "* [NeuType requires and NeuGroup satisfies](#NeuType-requires-and-NeuGroup-satisfies)\n",
    "* [NeuType hand_overs data/func to NeuGroup](#NeuType-hand_overs-data/func-to-NeuGroup)\n",
    "* [The advantages of the vector-based model](#The-advantages-of-the-vector-based-model)\n",
    "* [Object-oriented programming for NeuGroup](#Object-oriented-programming-for-NeuGroup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In BrainPy, the *definition* and *usage* of the neuron model is separated from each other. In such a way, users can recycle the defined models to generate different neuron groups, or can use models defined by other people. Specifically, two class should be used:\n",
    "\n",
    "- ``brainpy.NeuType``: Define the abstract neuron model.\n",
    "- ``brainpy.NeuGroup``: Use the abstract neuron model to generate a concrete neuron group for computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:12:37.820385Z",
     "start_time": "2020-11-24T03:12:34.962065Z"
    }
   },
   "outputs": [],
   "source": [
    "import brainpy as bp\n",
    "import numpy as np\n",
    "\n",
    "bp.profile.set(dt=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.NeuType"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Three items should be specified to initialize a ``NeuType``:\n",
    "\n",
    "- ``ST``: The neuronal state.\n",
    "- ``name``: The neuron model name.\n",
    "- ``steps``: The step functions to update at each time step.\n",
    "- ``requires``: The data requires to run the defined model (optional)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two kinds of definition are provided in BrainPy to define a ``NeuType``: \n",
    "\n",
    "- ``scalar-based``: Each item in ``ST`` is a scalar, which represents the state of a single neuron. \n",
    "- ``vector-based``: Each item in ``ST`` is a vector, which represents the state of a group of neurons.\n",
    "\n",
    "The definition logic of ``scalar-based`` models may be more straightforward than ``vector-based`` models. We will see this in the example of LIF model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hodgkin-Huxley model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first take the Hodgkin-Huxley (HH) neuron model as an example to see how to define a ``NeuType`` in BrainPy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:30:37.766010Z",
     "start_time": "2020-11-24T03:30:37.760029Z"
    }
   },
   "outputs": [],
   "source": [
    "# parameters we need # \n",
    "# ------------------ #\n",
    "\n",
    "C = 1.0  # Membrane capacity per unit area (assumed constant).\n",
    "g_Na = 120.  # Voltage-controlled conductance per unit area\n",
    "             # associated with the Sodium (Na) ion-channel.\n",
    "E_Na = 50.   # The equilibrium potentials for the sodium ions.\n",
    "E_K = -77.   # The equilibrium potentials for the potassium ions.\n",
    "g_K = 36.  # Voltage-controlled conductance per unit area\n",
    "           # associated with the Potassium (K) ion-channel.\n",
    "E_Leak = -54.402  # The equilibrium potentials for the potassium ions.\n",
    "g_Leak = 0.003 # Conductance per unit area associated with the leak channels.\n",
    "Vth = 20.  # membrane potential threshold for spike"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Four differential equations exist in HH neuron model. Please check [Differential equations](https://brainpy.readthedocs.io/en/latest/advanced/differential_equations.html) to see how BrainPy supports differential equations. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For $m$ channel, the difinition of the corresponding equations can be:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align}\n",
    "{\\frac {dm}{dt}} &=\\alpha _{m}(V)(1-m)-\\beta _{m}(V)m  \\\\\n",
    "\\alpha_m(V) &= {0.1 (V+ 40) \\over 1-\\exp\\big(-{ V+40 \\over 10}\\big)} \\\\\n",
    "\\beta_m(V) &= 4.0 \\cdot \\exp\\big(-{V+65 \\over 18}\\big)\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:13:17.628936Z",
     "start_time": "2020-11-24T03:13:17.615937Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_m(m, t, V):\n",
    "    alpha = 0.1 * (V + 40) / (1 - np.exp(-(V + 40) / 10))\n",
    "    beta = 4.0 * np.exp(-(V + 65) / 18)\n",
    "    dmdt = alpha * (1 - m) - beta * m\n",
    "    return dmdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $h$ channel is defined as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "{\\frac {dm}{dt}} &=\\alpha _{m}(V)(1-m)-\\beta _{m}(V)m  \\\\\n",
    "\\alpha_m(V) &= {0.1 (V+ 40) \\over 1-\\exp\\big(-{ V+40 \\over 10}\\big)} \\\\\n",
    "\\beta_m(V) &= 4.0 \\cdot \\exp\\big(-{V+65 \\over 18}\\big)\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:13:33.719989Z",
     "start_time": "2020-11-24T03:13:33.712010Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_h(h, t, V):\n",
    "    alpha = 0.07 * np.exp(-(V + 65) / 20.)\n",
    "    beta = 1 / (1 + np.exp(-(V + 35) / 10))\n",
    "    dhdt = alpha * (1 - h) - beta * h\n",
    "    return dhdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $n$ channel is defined as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "{\\frac {dn}{dt}} &=\\alpha _{n}(V)(1-n)-\\beta _{n}(V)n \\\\\n",
    "\\alpha_n(V) &= {0.1 \\cdot (V+55) \\over 1-\\exp\\big(-{V+55 \\over10}\\big)} \\\\\n",
    "\\beta_n(V) &= 0.125 \\cdot \\exp\\big(-{V+65 \\over 80}\\big)\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:13:58.080211Z",
     "start_time": "2020-11-24T03:13:58.072228Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_n(n, t, V):\n",
    "    alpha = 0.01 * (V + 55) / (1 - np.exp(-(V + 55) / 10))\n",
    "    beta = 0.125 * np.exp(-(V + 65) / 80)\n",
    "    dndt = alpha * (1 - n) - beta * n\n",
    "    return dndt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The membrane potential $V$ is defined as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "C_{m}{\\frac {d V}{dt}}&=-{\\bar {g}}_{\\text{K}}n^{4}(V-V_{K}) - {\\bar {g}}_{\\text{Na}}m^{3}h(V-V_{Na}) -{\\bar {g}}_{l}(V-V_{l}) + I_{syn}\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:14:17.809645Z",
     "start_time": "2020-11-24T03:14:17.798673Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_V(V, t, m, h, n, Isyn):\n",
    "    INa = g_Na * m ** 3 * h * (V - E_Na)\n",
    "    IK = g_K * n ** 4 * (V - E_K)\n",
    "    IL = g_Leak * (V - E_Leak)\n",
    "    dvdt = (- INa - IK - IL + Isyn) / C\n",
    "    return dvdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In BrainPy, most of the integration of differential equations are implemented by the numerical methods, such as Euler, Exponential Euler, RK2, RK4 (please see [Numerical integrators](https://brainpy.readthedocs.io/en/latest/advanced/numerical_integrators.html)). Therefore, after defining the differential equations, the next important thing is to define the update logic for each variable from the current time point to the next. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, let's first define the state of a HH model. We provide a data structure ``brainpy.types.NeuState`` to support the neuron state management."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:29:35.517510Z",
     "start_time": "2020-11-24T03:29:35.511496Z"
    }
   },
   "outputs": [],
   "source": [
    "ST = bp.types.NeuState(\n",
    "     'm',  # denotes potassium channel activation probability.\n",
    "     'h',  # denotes sodium channel activation probability.\n",
    "     'n',  # denotes sodium channel inactivation probability.\n",
    "     'spike',  # denotes spiking state.\n",
    "     'input',  # denotes synaptic input.\n",
    "     V=-65.,  # denotes membrane potential.\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In ``ST``, the dynamical variable $V$, $m$, $h$, and $n$ are inluded (without the value specification, the default value of $m$ and $n$ will be 0.). We also take care about whether the neuron produce a $spike$ at current time. Moreover, we define a $input$ item to receive the synaptic inputs and the external inputs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the neuron state ``ST``, the update logic of the HH model from the current time point ($t$) to the next time point $(t + dt)$ can be defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:29:44.199256Z",
     "start_time": "2020-11-24T03:29:44.186295Z"
    }
   },
   "outputs": [],
   "source": [
    "def update(ST, _t):\n",
    "    m = np.clip(int_m(ST['m'], _t, ST['V']), 0., 1.)\n",
    "    h = np.clip(int_h(ST['h'], _t, ST['V']), 0., 1.)\n",
    "    n = np.clip(int_n(ST['n'], _t, ST['V']), 0., 1.)\n",
    "    V = int_V(ST['V'], _t, ST['m'], ST['h'], ST['n'], ST['input'])\n",
    "    \n",
    "    ST['spike'] = np.logical_and(ST['V'] < Vth, V >= Vth)\n",
    "    ST['V'] = V\n",
    "    ST['m'] = m\n",
    "    ST['h'] = h\n",
    "    ST['n'] = n\n",
    "    ST['input'] = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the ``update()`` function of HH model needs two data:\n",
    "\n",
    "- ``ST``: The neuron state.\n",
    "- ``_t``: The system time at current point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting together, a HH neuron model is defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T03:34:33.455980Z",
     "start_time": "2020-11-24T03:34:33.450999Z"
    }
   },
   "outputs": [],
   "source": [
    "HH = bp.NeuType(name='HH_neuron', \n",
    "                ST=ST, \n",
    "                steps=update,\n",
    "                mode='vector')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we should note that we just define an abstract HH neuron model. This model can run with any number of neurons, and with any geometry (one dimension, or two dimension). Only after define a concrete [neuron group](#brainpy.NeuGroup), can we run it or use it to construct a network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LIF model (vector-based)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, same with [HH model](#Hodgkin-Huxley-model) defined above, let's define a vector-based LIF model. The formal equations of a LIF model is given by:\n",
    "\n",
    "$$\n",
    "\\tau_m \\frac{dV}{dt} = - (V(t) - V_{rest}) + I(t) \n",
    "\\\\\n",
    "\\text{after}\\, V(t) \\gt V_{th}, V(t) =V_{rest}\n",
    "\\,\n",
    "\\text{last}\\, \\tau_{ref}\\, \\text{ms} \n",
    "$$\n",
    "\n",
    "where $V$ is the membrane potential, $V_{rest}$ is the rest membrane potential, $V_{th}$ is the spike threshold, $\\tau_m$ is the time constant, $\\tau_{ref}$ is the refractory time period, and $I$ is the time-variant synaptic inputs. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the following item in neuron state:\n",
    "\n",
    "- ``V``: The membrane potential.\n",
    "- ``input``: The synaptic input.\n",
    "- ``spike``: Whether produce a spike.\n",
    "- ``refractory``: Whether the neuron is in refractory state.\n",
    "- ``t_last_spike``: The last spike time for calculating refractory state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T04:25:05.900622Z",
     "start_time": "2020-11-24T04:25:05.890683Z"
    }
   },
   "outputs": [],
   "source": [
    "ST = bp.types.NeuState(\n",
    "        'V',     # membrane potential\n",
    "         'input',  # synaptic input\n",
    "         'spike',  # spike state\n",
    "         'refractory',  # refractory state\n",
    "         t_last_spike=-1e7  # last spike time\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume the items in the neuron state ``ST`` of a LIF model are vectors, the update logic of vector-based LIF neuron model is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T04:39:13.231721Z",
     "start_time": "2020-11-24T04:39:13.216761Z"
    }
   },
   "outputs": [],
   "source": [
    "tau_m=10.; Vr=0.; Vth=10.; tau_ref=0.\n",
    "\n",
    "@bp.integrate\n",
    "def int_f(V, t, Isyn):\n",
    "    return (-V + Vr + Isyn) / tau_m\n",
    "\n",
    "def update(ST, _t):\n",
    "    V = int_f(ST['V'], _t, ST['input'])\n",
    "    is_ref = _t - ST['t_last_spike'] < tau_ref\n",
    "    V = np.where(is_ref, ST['V'], V)\n",
    "    is_spike = V > Vth\n",
    "    \n",
    "    # get the position of neurons which produce spikes\n",
    "    spike_idx = np.where(is_spike)[0]\n",
    "    if len(spike_idx):\n",
    "        V[spike_idx] = Vr\n",
    "        is_ref[spike_idx] = 1.\n",
    "        ST['t_last_spike'][spike_idx] = _t\n",
    "    \n",
    "    # update the item\n",
    "    ST['V'] = V\n",
    "    ST['spike'] = is_spike\n",
    "    ST['refractory'] = is_ref\n",
    "    ST['input'] = 0.\n",
    "\n",
    "lif = bp.NeuType(name='LIF', \n",
    "                 ST=ST, \n",
    "                 steps=update, \n",
    "                 mode='vector')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, for vector-based LIF model, we must differentiate the states for each neuron at every time point. For neurons in refractory period (``is_ref``), we must keep its $V$ unchange. For neurons in spiking state (``is_spike``), we must reset its membrane potential. So, it looks like the definition of vector-based LIF mode is somewhat complex. However, the good news is that BrainPy support the difinition of neuron models in scalar mode, which means at each time point, your model difinition can only consider the behavior of one single neuron. Let's take a look."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LIF model (scalar-based)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T04:47:43.050010Z",
     "start_time": "2020-11-24T04:47:43.041032Z"
    }
   },
   "outputs": [],
   "source": [
    "def update(ST, _t):\n",
    "    if _t - ST['t_last_spike'] > tau_ref:\n",
    "        V = int_f(ST['V'], _t, ST['input'])\n",
    "        if V >= Vth:\n",
    "            V = Vr\n",
    "            ST['t_last_spike'] = _t\n",
    "            ST['spike'] = True\n",
    "        ST['V'] = V\n",
    "    else:\n",
    "        ST['spike'] = False\n",
    "    ST['input'] = 0.\n",
    "    \n",
    "lif = bp.NeuType(name='LIF', \n",
    "                 ST=ST, \n",
    "                 steps=update, \n",
    "                 mode='scalar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the scalar-based LIF model is intuitive and straightforward in BrainPy. If the neuron is not in refractory period (``_t - ST['t_last_spike'] > tau_ref``), integrate the membrane potential by calling ``int_f()``. If the neuron reaches the spike threshold (``V >= Vth``), then reset the membrane potential (``V = Vr``) and set the spike state to bs ``True``. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it's worthy to note that the scalar-based and the vector-based model have different flexibility ratio. The scalar-based model is convinient and easy to define, but is not flexible enough like the vector-based model. For the vector-based model, you can control everything, and define any data you want. For example, you can operate on the whole group level to count the total spikes by defining a variable `total_spike`, or get the instantaneous population firing rate, etc. Later, we will come back to this topic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.NeuGroup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we talk about ``brainpy.NeuType``, the uasge of ``brainpy.NeuGroup`` is a piece of cake. This is because in a real project the most efforts we pay is the *difinition* of the models, and BrainPy provide a very convenient way to *use* your defined models. Specifically, a ``brainpy.NeuGroup`` receives the following specifications:\n",
    "\n",
    "- ``model``: The neuron type will be used to generate a neuron group.\n",
    "- ``geometry``: The geometry of the neuron group. Can be a int, or a tuple/list of int.\n",
    "- ``monitors``: The items to monitor (record the history values.)\n",
    "- ``name``: The neuron group name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take our defined HH model as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T05:22:26.727483Z",
     "start_time": "2020-11-24T05:22:26.715548Z"
    }
   },
   "outputs": [],
   "source": [
    "group = bp.NeuGroup(HH, geometry=10, monitors=['V', 'm', 'n', 'h'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each group has a powerful function: ``.run()``. In this function, it receives the following arguments:\n",
    "\n",
    "- ``duration``: Specify the simulation duration. Can be a tuple with ``(start time, end time)``. Or it can be a int to specify the duration ``length`` (then the default start time is ``0``).\n",
    "- ``inputs``: Specify the inputs for each model component. With the format of ``(target, value, [operation])``. The default operation is ``+``, which means the input ``value`` will be added to the ``target``. Or, the operation can be ``-``, ``*``, ``/``, or ``=``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 10.0% used 0.104 s.\n",
      "Run 20.0% used 0.208 s.\n",
      "Run 30.0% used 0.317 s.\n",
      "Run 40.0% used 0.420 s.\n",
      "Run 50.0% used 0.522 s.\n",
      "Run 60.0% used 0.632 s.\n",
      "Run 70.0% used 0.738 s.\n",
      "Run 80.0% used 0.844 s.\n",
      "Run 90.0% used 0.952 s.\n",
      "Run 100.0% used 1.059 s.\n",
      "Simulation is done in 1.059 s.\n"
     ]
    }
   ],
   "source": [
    "group.run(100., inputs=('ST.input', 5.), report=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bp.visualize.line_plot(group.mon.ts, group.mon.V, show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bp.visualize.line_plot(group.mon.ts, group.mon.m, legend='m')\n",
    "bp.visualize.line_plot(group.mon.ts, group.mon.h, legend='h')\n",
    "bp.visualize.line_plot(group.mon.ts, group.mon.n, legend='n', show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reconcile the scalar- and vector-based model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scalar-bsed and the vector-based model have different performance under different settings. When the users run the model without JIT acceleration (or ``profile.set(jit=False)``), the vector-based model is much more efficient than the scalar-based model due to the powerful array-oriented programming support in NumPy. On the contrary, the scalar-based *LIF* model sometimes is efficient than the vector-based ones in ``JIT`` mode (However, for the neuron model without too many `if .. else ...` conditions, the vector-based nueron is much more efficient, for example, the HH model). This is thanks to the JIT acceleration of for loop provided in Numba. Therefore, we recommend you to choose different difinition mode for different running backend. For example, we can define a unified LIF model with the explicit backend judgement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-24T05:04:09.328819Z",
     "start_time": "2020-11-24T05:04:09.310904Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_lif(tau_m=10., Vr=0., Vth=10., tau_ref=0.):\n",
    "    ST = bp.types.NeuState({'V': 0, 'input':0, 'spike':0, \n",
    "                            'refractory': 0, 't_last_spike': -1e7})\n",
    "    \n",
    "    @bp.integrate\n",
    "    def int_f(V, t, Isyn):\n",
    "        return (-V + Vr + Isyn) / tau_m\n",
    "\n",
    "    if bp.profile.is_jit():\n",
    "    \n",
    "        def update(ST, _t):\n",
    "            if _t - ST['t_last_spike'] > tau_ref:\n",
    "                V = int_f(ST['V'], _t, ST['input'])\n",
    "                if V >= Vth:\n",
    "                    V = Vr\n",
    "                    ST['t_last_spike'] = _t\n",
    "                    ST['spike'] = True\n",
    "                ST['V'] = V\n",
    "            else:\n",
    "                ST['spike'] = False\n",
    "            ST['input'] = 0.\n",
    "\n",
    "        lif = bp.NeuType(name='LIF', ST=ST, steps=update, mode='scalar')\n",
    "        \n",
    "        \n",
    "    else:\n",
    "        \n",
    "        def update(ST, _t):\n",
    "            V = int_f(ST['V'], _t, ST['input'])\n",
    "            is_ref = _t - ST['t_last_spike'] < tau_ref\n",
    "            V = np.where(is_ref, ST['V'], V)\n",
    "            is_spike = V > Vth\n",
    "            spike_idx = np.where(is_spike)[0]\n",
    "            if len(spike_idx):\n",
    "                V[spike_idx] = Vr\n",
    "                is_ref[spike_idx] = 1.\n",
    "                ST['t_last_spike'][spike_idx] = _t\n",
    "            ST['V'] = V\n",
    "            ST['spike'] = is_spike\n",
    "            ST['refractory'] = is_ref\n",
    "            ST['input'] = 0.\n",
    "\n",
    "        lif = bp.NeuType(name='LIF', ST=ST, steps=update, mode='vector')\n",
    "    \n",
    "    return lif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NeuType `requires` and NeuGroup `satisfies`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The design of BrainPy is constrained by the two goals:\n",
    "\n",
    "- JIT support. \n",
    "- The model definition and usage separation.\n",
    "\n",
    "BrainPy heavily relies on [Numba](https://numba.pydata.org/). Unfortunately, Numba has poor support for `Python class`. And the performance of class computation is greatly reduced. In order to get the best JIT performace, BrainPy only allow users to define models by using the `Python function`. \n",
    "\n",
    "On the other hand, in order to recycle the defined models and hold model reproducibility, BranPy provides ``NeuType`` for model definition and ``NeuGroup`` for model usage. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, one core feature of BrainPy is to bring the computation of a class onto the function. In a class, any data you want can be accessed by ``self.xxx``. In the function, such data ``xxx`` you **require** can be defined as an argument in ``NeuType`` step function. When using ``NeuGroup``, user must initialize the data ``xxx`` to **satisfy** the step function requires."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../images/class_comp_to_func.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take the following illustrating model as an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update(ST, _t, data1, data2):\n",
    "    ...\n",
    "\n",
    "neu = bp.NeuType('test', ST=bp.NeuState(), steps=update,\n",
    "                 requires={'data1': bp.types.Array(dim=1),\n",
    "                           'data2': bp.types.Array(dim=2)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The neuron type ``neu`` *requires* `data1` (a one-dimensional array) and `data2` (a two-dimensional array) to compute its update function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "group = bp.NeuGroup(neu, geometry=1, \n",
    "                    satisfies={'data1': np.zeros(10), \n",
    "                               'data2':  np.ones((10, 10))})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When someone uses this defined model, he/she must provide the corresponding data (`data1` and `data2`) in the ``NeuGroup`` to *satisfy* the ``NeuType`` requirements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, one can also provide the required data in the following ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "group = bp.NeuGroup(neu, geometry=1)\n",
    "group.data1 = np.zeros(10)\n",
    "group.data2 = np.ones((10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NeuType `hand_overs` data/func to NeuGroup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful keyword provided in ``NueType`` is ``hand_overs``, which means you can hand over the data or the functions defined in the ``NeuType`` to the ``NeuGroup`` when someone want to use. For example, you can define a ``init_state()`` function to initialize the HH neuron model state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "ST = bp.types.NeuState('V', 'm', 'h', 'n', 'spike', 'input')\n",
    "\n",
    "@bp.integrate\n",
    "def int_m(m, _t, V):\n",
    "    alpha = 0.1 * (V + 40) / (1 - np.exp(-(V + 40) / 10))\n",
    "    beta = 4.0 * np.exp(-(V + 65) / 18)\n",
    "    return alpha * (1 - m) - beta * m\n",
    "\n",
    "@bp.integrate\n",
    "def int_h(h, _t, V):\n",
    "    alpha = 0.07 * np.exp(-(V + 65) / 20.)\n",
    "    beta = 1 / (1 + np.exp(-(V + 35) / 10))\n",
    "    return alpha * (1 - h) - beta * h\n",
    "\n",
    "@bp.integrate\n",
    "def int_n(n, _t, V):\n",
    "    alpha = 0.01 * (V + 55) / (1 - np.exp(-(V + 55) / 10))\n",
    "    beta = 0.125 * np.exp(-(V + 65) / 80)\n",
    "    return alpha * (1 - n) - beta * n\n",
    "\n",
    "@bp.integrate\n",
    "def int_V(V, _t, m, h, n, I_ext):\n",
    "    I_Na = (g_Na * np.power(m, 3.0) * h) * (V - E_Na)\n",
    "    I_K = (g_K * np.power(n, 4.0))* (V - E_K)\n",
    "    I_leak = g_leak * (V - E_leak)\n",
    "    dVdt = (- I_Na - I_K - I_leak + I_ext)/C \n",
    "    return dVdt, noise / C\n",
    "\n",
    "# update the variables change over time (for each step)\n",
    "def update(ST, _t):\n",
    "    m = np.clip(int_m(ST['m'], _t, ST['V']), 0., 1.)\n",
    "    h = np.clip(int_h(ST['h'], _t, ST['V']), 0., 1.)\n",
    "    n = np.clip(int_n(ST['n'], _t, ST['V']), 0., 1.)\n",
    "    V = int_V(ST['V'], _t, m, h, n, ST['input'])\n",
    "    spike = np.logical_and(ST['V'] < V_th, V >= V_th)\n",
    "    ST['spike'] = spike\n",
    "    ST['V'] = V\n",
    "    ST['m'] = m\n",
    "    ST['h'] = h\n",
    "    ST['n'] = n\n",
    "    ST['input'] = 0.   \n",
    "\n",
    "def init_state(ST, Vr):\n",
    "    ST['V'] = Vr\n",
    "    V = ST['V']\n",
    "    \n",
    "    alpha = 0.1 * (V + 40) / (1 - np.exp(-(V + 40) / 10))\n",
    "    beta = 4.0 * np.exp(-(V + 65) / 18)\n",
    "    ST['m'] = alpha / (alpha + beta)\n",
    "    \n",
    "    alpha = 0.07 * np.exp(-(V + 65) / 20.)\n",
    "    beta = 1 / (1 + np.exp(-(V + 35) / 10))\n",
    "    ST['h'] = alpha / (alpha + beta)\n",
    "    \n",
    "    alpha = 0.01 * (V + 55) / (1 - np.exp(-(V + 55) / 10))\n",
    "    beta = 0.125 * np.exp(-(V + 65) / 80)\n",
    "    ST['n'] = alpha / (alpha + beta)\n",
    "    \n",
    "HH_neu = bp.NeuType(name='HH_neuron', \n",
    "                    ST=ST, \n",
    "                    steps=update, \n",
    "                    mode='vector',\n",
    "                    hand_overs={'init_state': init_state})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you use this model, you can easily initialize the model state by using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "HH_group = bp.NeuGroup(HH_neu, geometry=10)\n",
    "HH_group.init_state(HH_group.ST, np.random.random(10) * 10 - 75.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-70.9077187 , -66.55979129, -65.14340083, -69.51226795,\n",
       "       -73.38228859, -68.06085232, -72.08114256, -71.82573823,\n",
       "       -71.86175207, -72.1604964 ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HH_group.ST['V']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.02582321, 0.04396935, 0.05204429, 0.03070063, 0.01891655,\n",
       "       0.03667513, 0.02229492, 0.02302182, 0.02291798, 0.02207352])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HH_group.ST['m']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The advantages of the vector-based model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage of the vector-based model is that you can control all the things that will happend in a neuron group. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, you can define a variable ``spike_num`` to count the spike number in a neuron group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "tau_m=10.; Vr=0.; Vth=10.; tau_ref=0.\n",
    "\n",
    "ST = bp.types.NeuState('V', 'input', 'spike', t_last_spike=-1e7 )\n",
    "\n",
    "@bp.integrate\n",
    "def int_f(V, t, Isyn):\n",
    "    return (-V + Vr + Isyn) / tau_m\n",
    "\n",
    "def update(ST, _t, spike_num):\n",
    "    V = int_f(ST['V'], _t, ST['input'])\n",
    "    is_spike = V > Vth\n",
    "    spike_idx = np.where(is_spike)[0]\n",
    "    num_sp = len(spike_idx)\n",
    "    spike_num[0] += num_sp\n",
    "    if num_sp > 0:\n",
    "        V[spike_idx] = Vr\n",
    "        ST['t_last_spike'][spike_idx] = _t\n",
    "    ST['V'] = V\n",
    "    ST['spike'] = is_spike\n",
    "    ST['input'] = 0.\n",
    "\n",
    "lif2 = bp.NeuType(name='LIF',ST=ST, steps=update, mode='vector',\n",
    "                  hand_overs={'spike_num': np.array([0])})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we define `spike_num` in ``update()`` function, and initialize `spike_num` as `np.array([0])` in the ``hand_overs``. In such a way, any instance of ``NeuGroup`` for such neuron type will automatically have the required data `spike_num`. Note here we use a array to get the spike number, this is because BrainPy do not support step function return (by using arrays, this problem can be easily solved)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "group = bp.NeuGroup(lif2, geometry=10, monitors=['spike'])\n",
    "group.run(100., inputs=('input', np.random.random(10) * 5 + 10.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group.spike_num[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group.mon.spike.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object-oriented programming for ``NeuGroup``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "BrainPy seperates the processes of model definition and model usage, and it is further constrained to use ``Python function`` to define models. However, there are always neuron-group-oriented models. \n",
    "\n",
    "Fortunately, in BrainPy, users can define specific neuron groups in a manner of object-oriented programming by inheriting ``bp.NeuGroup``. Let's take the poisson neuron group and the continuous-attractor network as examples to illustrate how to define group-oriented models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CANN example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all, we here define a continuouse-attractor neural network, which is an implementation of the paper: \n",
    "\n",
    "- Si Wu, Kosuke Hamaguchi, and Shun-ichi Amari. “Dynamics and computation of continuous attractors.” Neural computation 20.4 (2008): 994-1025.\n",
    "\n",
    "Detailed implementation please see [Wu_2008_CANN](https://brainpy-models.readthedocs.io/en/latest/examples/from_papers/Wu_2008_CANN.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "bp.profile.set(numerical_method='rk4', dt=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CANN(bp.NeuGroup):\n",
    "    \"\"\"\n",
    "    Define a Continuous-attractor Neural Network neuron\n",
    "    group by using the object-oriented programming.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self,\n",
    "                 num,\n",
    "                 tau=1.,  # The synaptic time constant\n",
    "                 k=8.1,  # Degree of the rescaled inhibition\n",
    "                 a=0.5,  # Half-width of the range of excitatory connections\n",
    "                 A=10.,  # Magnitude of the external input\n",
    "                 J0=4.,  # maximum connection value\n",
    "                 z_min=-np.pi,\n",
    "                 z_max=np.pi,\n",
    "                 monitors=None):\n",
    "        self.a = a\n",
    "        self.A = A\n",
    "        self.J0 = J0\n",
    "        self.z_min = z_min\n",
    "        self.z_max = z_max\n",
    "        self.num = num\n",
    "\n",
    "        self.z_range = z_max - z_min\n",
    "        # The neural density\n",
    "        rho = num / self.z_range\n",
    "        # The stimulus density\n",
    "        dx = self.z_range / num\n",
    "        # The corresponding stimulus\n",
    "        xs = np.linspace(z_min, z_max, num)\n",
    "        # The connection matrix\n",
    "        conn_mat = self.make_conn(xs)\n",
    "\n",
    "        @bp.integrate\n",
    "        def int_u(u, t, Iext):\n",
    "            r1 = np.square(u)\n",
    "            r2 = 1.0 + k * rho * np.sum(r1) * dx\n",
    "            r = r1 / r2\n",
    "            Irec = rho * np.dot(conn_mat, r) * dx\n",
    "            dudt = (-u + Irec + Iext) / tau\n",
    "            return (dudt,), r\n",
    "\n",
    "        def neu_update(ST, _t):\n",
    "            ST['u'], ST['r'] = int_u(ST['u'], _t, ST['input'])\n",
    "            ST['input'] = 0.\n",
    "\n",
    "        # define the model\n",
    "        model = bp.NeuType(name='CANN',\n",
    "                           steps=neu_update,\n",
    "                           ST=bp.types.NeuState('x', 'u', 'r', 'input'),\n",
    "                           mode='vector')\n",
    "\n",
    "        super(CANN, self).__init__(model=model, geometry=num, monitors=monitors)\n",
    "\n",
    "        # initialize the \"x\"\n",
    "        self.ST['x'] = xs\n",
    "\n",
    "    def dist(self, d):\n",
    "        d = np.remainder(d, self.z_range)\n",
    "        d = np.where(d > 0.5 * self.z_range, d - self.z_range, d)\n",
    "        return d\n",
    "\n",
    "    def make_conn(self, x):\n",
    "        assert np.ndim(x) == 1\n",
    "        x_left = np.reshape(x, (len(x), 1))\n",
    "        x_right = np.repeat(x.reshape((1, -1)), len(x), axis=0)\n",
    "        d = self.dist(x_left - x_right)\n",
    "        jxx = self.J0 * np.exp(-0.5 * np.square(d / self.a)) / (np.sqrt(2 * np.pi) * self.a)\n",
    "        return jxx\n",
    "\n",
    "    def get_stimulus_by_pos(self, pos):\n",
    "        return self.A * np.exp(-0.25 * np.square(self.dist(self.ST['x'] - pos) / self.a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instance the neuron group\n",
    "\n",
    "group = CANN(512, monitors=['u'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the moving stimulus\n",
    "\n",
    "dur1, dur2, dur3 = 20., 20., 20.\n",
    "num1 = int(dur1 / bp.profile.get_dt())\n",
    "num2 = int(dur2 / bp.profile.get_dt())\n",
    "num3 = int(dur3 / bp.profile.get_dt())\n",
    "position = np.zeros(num1 + num2 + num3)\n",
    "position[num1: num1 + num2] = np.linspace(0., 12., num2)\n",
    "position[num1 + num2:] = 12.\n",
    "position = position.reshape((-1, 1))\n",
    "Iext = group.get_stimulus_by_pos(position)\n",
    "group.run(duration=dur1 + dur2 + dur3, inputs=('ST.input', Iext))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "bp.visualize.animate_1D(\n",
    "    dynamical_vars=[{'ys': group.mon.u, 'xs': group.ST['x'], 'legend': 'u'},\n",
    "                    {'ys': Iext, 'xs': group.ST['x'], 'legend': 'Iext'}],\n",
    "    frame_step=5,\n",
    "    frame_delay=50,\n",
    "    show=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simulation results please see [Wu_2008_CANN](https://brainpy-models.readthedocs.io/en/latest/examples/from_papers/Wu_2008_CANN.html#Smooth-tracking)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Poisson noise example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poisson noise is usually used in the computational modeling. And, obviously, there is no dynamics in a Poisson group. Directly define a Poisson group by``PoissonGroup(freq=xxx, geometry=xxx)`` is much better than using ``NeuGroup(model=poisson(freq=xx), geometry=xxx)``. So, here is the example how to define a Poisson group model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PoissonInput(bp.NeuGroup):\n",
    "    def __init__(self, geometry, freqs, monitors=None):\n",
    "        dt = bp.profile.get_dt() / 1000.\n",
    "\n",
    "        def update(ST):\n",
    "            ST['spike'] = np.random.random(ST['spike'].shape) < freqs * dt\n",
    "\n",
    "        model = bp.NeuType(name='poisson', ST=bp.NeuState('spike'), steps=update, mode='vector')\n",
    "\n",
    "        super(PoissonInput, self).__init__(model=model, geometry=geometry, monitors=monitors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 100 Hz Poisson noise\n",
    "\n",
    "group = PoissonInput(100, freqs=100., monitors=['spike'])\n",
    "group.run(100.)\n",
    "bp.visualize.raster_plot(group.mon.ts, group.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 500 Hz Poisson noise\n",
    "\n",
    "group = PoissonInput(100, freqs=500., monitors=['spike'])\n",
    "group.run(100.)\n",
    "bp.visualize.raster_plot(group.mon.ts, group.mon.spike, show=True)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "243.07px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
